.TH std::jthread::join 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::jthread::join \- std::jthread::join

.SH Synopsis
   void join();  \fI(since C++20)\fP

   Blocks the current thread until the thread identified by *this finishes its
   execution.

   The completion of the thread identified by *this synchronizes with the corresponding
   successful return from join().

   No synchronization is performed on *this itself. Concurrently calling join() on the
   same jthread object from multiple threads constitutes a data race that results in
   undefined behavior.

.SH Parameters

   \fI(none)\fP

.SH Return value

   \fI(none)\fP

.SH Postconditions

   joinable() is false.

.SH Exceptions

   std::system_error if an error occurs.

   Error conditions

     * resource_deadlock_would_occur if this->get_id() == std::this_thread::get_id()
       \fI(deadlock detected)\fP.
     * no_such_process if the thread is not valid.
     * invalid_argument if joinable() is false.

.SH Example


// Run this code

 #include <chrono>
 #include <iostream>
 #include <thread>

 void foo()
 {
     // simulate expensive operation
     std::this_thread::sleep_for(std::chrono::seconds(1));
 }

 void bar()
 {
     // simulate expensive operation
     std::this_thread::sleep_for(std::chrono::seconds(1));
 }

 int main()
 {
     std::cout << "starting first helper...\\n";
     std::jthread helper1(foo);

     std::cout << "starting second helper...\\n";
     std::jthread helper2(bar);

     std::cout << "waiting for helpers to finish..." << std::endl;
     helper1.join();
     helper2.join();

     std::cout << "done!\\n";
 }

.SH Output:

 starting first helper...
 starting second helper...
 waiting for helpers to finish...
 done!

.SH References

     * C++23 standard (ISO/IEC 14882:2023):

     * 33.4.4.3 Members [thread.jthread.mem]
     * C++20 standard (ISO/IEC 14882:2020):

     * 32.4.3.2 Members [thread.jthread.mem]

.SH See also

   detach   permits the thread to execute independently from the thread handle
            \fI(public member function)\fP
            checks whether the thread is joinable, i.e. potentially running in parallel
   joinable context
            \fI(public member function)\fP
   C documentation for
   thrd_join
